<!DOCTYPE HTML>
<html class="no-js" lang="zh-CN">
<head><meta name="generator" content="Hexo 3.9.0">
    <!--[if lte IE 9]>
<meta http-equiv="refresh" content="0;url=https://grownzd.gitee.io/blog/warn.html">
<![endif]-->
<meta charset="utf-8">
<meta http-equiv="X-DNS-Prefetch-Control" content="on">
<link rel="dns-prefetch" href="https://grownzd.gitee.io/blog">
<link rel="dns-prefetch" href="//www.google-analytics.com">
<link rel="prefetch" href="https://grownzd.gitee.io/blog">
<link rel="prefetch" href="//www.google-analytics.com">


<link rel="prerender" href="https://grownzd.gitee.io/blog">

<meta http-equiv="X-UA-Compatible" content="IE=Edge">
<meta name="renderer" content="webkit">
<meta name="viewport" content="width=device-width, initial-scale=1.0,user-scalable=no">
<meta http-equiv="mobile-agent" content="format=html5; url=https://grownzd.gitee.io/blog">
<meta name="author" content="John Doe">
<link rel="stylesheet" href="/blog/css/JSimple.css">

<link rel="shortcut icon" href="/blog/images/favicon.png">


<title>第11-15天 - Hexo</title>

<meta name="keywords" content>

<meta name="description " content>

    <script type="text/x-mathjax-config">
        MathJax.Hub.Config({
            tex2jax: {
                inlineMath: [ ['$','$'], ["\\(","\\)"] ],
                processEscapes: true
            }
        });
    </script>


    

    

</head>
<body>
<div id="nav">
    <nav class="nav-menu">
        <a class="site-name current" href="/" title="说">说</a>
        <a class="site-index current" href="/"><i class="fa fa-home"></i><span>首页</span></a>
        <a href="/archives" title="归档"><i class="fa fa-archives"></i><span>归档</span></a>
        <a href="/tags" title="标签"><i class="fa fa-tags"></i><span>标签</span></a>
        <!-- custom single page of menus -->
        
        
        <a href="/help" title="帮助">
            <i class="fa fa-question-circle"></i>
            <span>帮助</span>
        </a>
        
    </nav>
</div>

<div class="nav-user">
    <a class="btn-search" href="#"><i class="fa fa-search"></i></a>
    <a class="btn-read-mode" href="#"><i class="fa fa-sun-o"></i></a>
    <a class="btn-sns-qr" href="javascript:"><i class="fa fa-telegram"></i></a>
</div>

<div id="wrapper" class="clearfix">
    <div id="body">
        <div class="main" id="main">
            <div id="cover">
    <div class="cover-img"></div>
    <div class="cover-info">
        
        <h1 class="cover-siteName">说IT</h1>
        <h3 class="cover-siteTitle">用代码摇滚这个世界</h3>
        <p class="cover-siteDesc">一个关注技术与人文的IT博客</p>
        <div class="cover-sns">
            
    &nbsp;&nbsp;<div class="btn btn-telegram">
        <a href="http://t.me/kunyintang" target="_blank" title="telegram" ref="friend">
            <i class="fa fa-telegram"></i>
        </a>
    </div>

    &nbsp;&nbsp;<div class="btn btn-instagram">
        <a href="https://www.instagram.com/mtangsir/" target="_blank" title="instagram" ref="friend">
            <i class="fa fa-instagram"></i>
        </a>
    </div>

    &nbsp;&nbsp;<div class="btn btn-twitter">
        <a href="https://twitter.com/tangkunyin" target="_blank" title="twitter" ref="friend">
            <i class="fa fa-twitter"></i>
        </a>
    </div>

    &nbsp;&nbsp;<div class="btn btn-github">
        <a href="https://github.com/tangkunyin" target="_blank" title="github" ref="friend">
            <i class="fa fa-github"></i>
        </a>
    </div>


        </div>
    </div>
</div>

            <div class="page-title">
    <ul>
        <li><a href="/">最近</a></li>
        
            
                <li class>
                    <a href="/categories/tech-notes" data-name="技术">技术</a>
                </li>
            
                <li class>
                    <a href="/categories/humanities" data-name="人文">人文</a>
                </li>
            
                <li class>
                    <a href="/categories/others" data-name="其他">其他</a>
                </li>
            
        
        <li class="page-search">
    <form id="search" class="search-form">
        <input type="text" readonly="readonly" id="local-search-input-tip" placeholder="读物检索~">
        <button type="button" disabled="disabled" class="search-form-submit"><i class="fa fa-search"></i></button>
    </form>
</li>

    </ul>
</div>
<div class="main-inner">
    <article class="post" itemscope itemtype="http://schema.org/BlogPosting">
        <div class="post-header">
            <div class="post-author clearfix">
                <a class="avatar fleft" href="https://grownzd.gitee.io/blog/" target="_blank">
                    <img width="48" src="/images/favicon.png" alt="avatar">
                </a>
                <p><span class="label">作者</span>
                    <a href="https://grownzd.gitee.io/page/" target="_blank">zd</a>
                    <span title="最后编辑于&nbsp;2019-06-30">2019-06-30</span>
                </p>
                <p>一个写代码的「伪文人」</p>
            </div>
            <h2 class="post-title">第11-15天</h2>
            <div class="post-meta">
                本文共计11281个字 |
                您是第&nbsp;<span id="busuanzi_value_page_pv"><i class="fa fa-spinner fa-spin"></i></span>位看到它们的小伙伴
            </div>
        </div>
        <div class="post-content markdown-body">
            <h1 id="第11-15天"><a href="#第11-15天" class="headerlink" title="第11-15天"></a>第11-15天</h1><p><strong>Object 类：</strong><br><strong>1. java.lang : 默认包，jvm 启动自动导入，该包里放的都是java程序设计的基础类。</strong><br><strong>2. 该类是根类，所有类都直接或者是间接的继承 Object，所有对象包括数组都继承了Object类中的方法。</strong><br><strong>方法：</strong><br><strong>boolean equals：比较的是两个对象的引用是否相同。</strong><br><strong>问题：“==” 和 equals()方法有啥区别？</strong>   </p>
<ol>
<li>== 既可以比较基本类型也可以比较引用类型。对于基本类型就是比较值，对于引用类型<br>就是比较内存地址。  </li>
<li>equals的话，它是属于java.lang.Object类里面的方法，如果该方法没有被重写过默认也<br>是==;我们可以看到String等类的equals方法是被重写过的，而且String类在日常开发中<br>用的比较多，久而久之，形成了equals是比较值的错误观点。  </li>
<li>具体要看自定义类里有没有重写Object的equals方法来判断。  </li>
<li>通常情况下，重写equals方法，会比较类中的相应属性是否都相等。 </li>
</ol>
<p><strong>int hashCode:</strong><br>　　返回对象的哈希值，每个对象都会有哈希值，通常情况下不同的对象哈希值一般不同，也有可能不同的对象哈希值相同(将 hashCode 方法重写)。因此，哈希值相同与不同不能决定是否是同一个对象。</p>
<p><strong>String toString：</strong><br>返回对象的字符串描述，格式：类名 + ‘@’+ hashCode()<br>该方法手动调用也好，不手动调用也好，当打印引用的引用名时，自动都会调用 Object 类中的 toString 方法。通常情况下，都会将该方法重写，显示的都是对象属性信息。</p>
<p><strong>编写对象类(实体类)步骤：</strong>  </p>
<ol>
<li>属性私有化  </li>
<li>构造方法(有参和无参)  </li>
<li>set 和 et 方法  </li>
<li>用于返回属性信息方法(重写 toString 方法)   </li>
</ol>
<p>#<strong>String 类：</strong><br>是一个 final 类，只要出现双引号表示的数据，那么这个数据就是 String 类的一个实例对象。双引号表示的数据是一个常量，即不可以改变。因此，对字符串做了某些操作，得到的都是一个新的字符串对象。  </p>
<figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line">String str = &quot;hello&quot;;</span><br><span class="line">//本质上this.value = new char[0];</span><br><span class="line">String s1 = new String(); </span><br><span class="line">//this.value = original.value;</span><br><span class="line">String s2 = new String(String original); </span><br><span class="line">//this.value = Arrays.copyOf(value, value.length);</span><br><span class="line">String s3 = new String(char[] a); </span><br><span class="line">String s4 = new String(char[] a,int startIndex,int count);</span><br></pre></td></tr></table></figure>

<p>方法：</p>
<blockquote>
<ol>
<li>int length()：返回字符串的长度： return value.length </li>
<li>char charAt(int index)：返回某索引处的字符return value[index] </li>
<li>boolean isEmpty()：判断是否是空字符串：return value.length == 0 </li>
<li>String toLowerCase()：使用默认语言环境，将 String 中的所有字符转换为小写</li>
<li>String toUpperCase()：使用默认语言环境，将 String 中的所有字符转换为大写 </li>
<li>String trim()：返回字符串的副本，忽略前导空白和尾部空白  </li>
<li>boolean equals(Object obj)：比较字符串的内容是否相同</li>
<li>boolean equalsIgnoreCase(String anotherString)：与equals方法类似，忽略大 小写 </li>
<li>String concat(String str)：将指定字符串连接到此字符串的结尾。 等价于用“+” </li>
<li>int compareTo(String anotherString)：比较两个字符串的大小 </li>
<li>String substring(int beginIndex)：返回一个新的字符串，它是此字符串的从 beginIndex开始截取到最后的一个子字符串。 </li>
<li>String substring(int beginIndex, int endIndex) ：返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。</li>
<li>boolean endsWith(String suffix)：测试此字符串是否以指定的后缀结束</li>
<li>boolean startsWith(String prefix)：测试此字符串是否以指定的前缀开始</li>
<li>boolean startsWith(String prefix, int toffset)：测试此字符串从指定索引开始的子字符串是否以指定前缀开始 </li>
<li>boolean contains(CharSequence s)：当且仅当此字符串包含指定的 char 值序列时，返回 true</li>
<li>int indexOf(String str)：返回指定子字符串在此字符串中第一次出现处的索引 </li>
<li>int indexOf(String str, int fromIndex)：返回指定子字符串在此字符串中第一次出 现处的索引，从指定的索引开始 </li>
<li>int lastIndexOf(String str)：返回指定子字符串在此字符串中最右边出现处的索引 </li>
<li>int lastIndexOf(String str, int fromIndex)：返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索 注：indexOf和lastIndexOf方法如果未找到都是返回-1 </li>
<li>String replace(char oldChar, char newChar)：返回一个新的字符串，它是 通过用 newChar替换此字符串中出现的所有 oldChar 得到的。</li>
<li>String replace(CharSequence target, CharSequence replacement)：使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。 </li>
<li>String replaceAll(String regex, String replacement) ： 使用给定的replacement替换此字符串所有匹配给定的正则表达式的子字符串。 </li>
<li>String replaceFirst(String regex, String replacement) ： 使 用 给 定 的 replacement<br>替换此字符串匹配给定的正则表达式的第一个子字符串。 </li>
<li>boolean matches(String regex)：告知此字符串是否匹配给定的正则表达式。 </li>
<li>String[] split(String regex)：根据给定正则表达式的匹配拆分此字符串。 </li>
<li>String[] split(String regex, int limit)：根据匹配给定的正则表达式来拆分此 字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中。</li>
</ol>
</blockquote>
<p>#<strong>字符串缓冲对象：</strong><br><strong>缓冲区：</strong></p>
<blockquote>
<p>可以理解为是一个容器，可以向容器中进行不同操作(添加，删除，修改，查看)， 最终得到一个唯一的字符串。 StringBuffer 和<br>StringBuilder 都是字符串缓冲区对象，功能是相同的，区别是： StringBuffer 是 jdk1.0<br>版本，StringBuilder 是 jdk1.5 版本；StringBuffer 是线程安全对象，效 率慢，StringBuilder<br>是线程不安全对象，效率高。</p>
</blockquote>
<p><strong>StringBuffer()：</strong></p>
<p>特点：可以改变的字符序列<br>String 和 字符串缓冲区对象是可以相互转换的：<br> 将字符串转为缓冲区对象new StringBuffer(String str)<br>缓冲区对象转为字符串：new String(StringBuffer s) 、toString() </p>
<p>构造方法：</p>
<blockquote>
<ol>
<li>初始容量为16的字符串缓冲区</li>
<li>StringBuffer(int size)：构造指定容量的字符串缓冲区</li>
<li>StringBuffer(String str)：将内容初始化为指定字符串内容</li>
</ol>
</blockquote>
<p>常用方法：</p>
<blockquote>
<ol>
<li>public int indexOf(String str)</li>
<li>public String substring(int start,int end)</li>
<li>public int length()</li>
<li>public char charAt(int n )</li>
<li>public void setCharAt(int n ,char ch)</li>
</ol>
</blockquote>
<p>包装类对象： </p>
<p>针对基本类型来进行设计的，基本类型有几个，包装对象就有几个，可以认为就是基本<br>类型也有对象形式。<br>基本类型：<br>byte short int long float double char boolean<br>包装类形式：<br>Byte Short Integer Long Float Double Character Boolean<br>包装类都是 final 类型，意味着不能有子类。因为包装类都有共同性，因此只要学习其<br>中一个类即可。<br>Integer 类为例：<br>重点： 包装类、 基本类型、字符串三者间的转换。<br><strong>包装对象——-&gt;基本</strong></p>
<blockquote>
<p>intValue()</p>
</blockquote>
<p><strong>基本类型——-&gt;包装对象</strong></p>
<blockquote>
<p> new Integer(int)   Integer.valueOf(int)</p>
</blockquote>
<p><strong>基本—–&gt;字符串</strong></p>
<blockquote>
<p> 调用字符串重载的valueOf()方法：<code>String fstr = String.valueOf(2.34f);</code><br>更直接的方式：<code>String intStr = 5 + &quot;&quot;</code></p>
</blockquote>
<p><strong>字符串—–&gt;基本</strong>  </p>
<blockquote>
<p>通过包装类的构造器实现：int i = new Integer(“12”);<br>通过包装类的parseXxx(String s)静态方法：<code>Float f = Float.parseFloat(“12.1”);</code><br>注意：Character 类中没有，其他都有</p>
</blockquote>
<p><strong>包装类—–&gt;字符串</strong></p>
<blockquote>
<p>String.valueOf(int)</p>
</blockquote>
<p><strong>字符串——&gt;包装类</strong></p>
<blockquote>
<p> new Integer(str)<br> Integer.valueOf(str)</p>
</blockquote>
<p>常用方法：</p>
<figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br></pre></td><td class="code"><pre><span class="line">int i = 500;</span><br><span class="line">Integer t = new Integer(i);</span><br><span class="line">装箱：包装类使得一个基本数据类型的数据变成了类。</span><br><span class="line">有了类的特点，可以调用类中的方法。</span><br><span class="line">String s = t.toString(); // s = “500“,t是类，有toString方法</span><br><span class="line">String s1 = Integer.toString(314); // s1= “314“ 将数字转换成字符串。</span><br><span class="line">String s2=“4.56”;</span><br><span class="line">double ds=Double.parseDouble(s2); //将字符串转换成数字</span><br><span class="line">拆箱：将数字包装类中内容变为基本数据类型。</span><br><span class="line">int j = t.intValue(); // j = 500，intValue取出包装类中的数据</span><br><span class="line">包装类在实际开发中用的最多的在于字符串变为基本数据类型。</span><br><span class="line">String str1 = &quot;30&quot; ;</span><br><span class="line">String str2 = &quot;30.3&quot; ;</span><br><span class="line">int x = Integer.parseInt(str1) ; // 将字符串变为int型</span><br><span class="line">float f = Float.parseFloat(str2) ; // 将字符串变为int型</span><br></pre></td></tr></table></figure>

<p><strong>基本数据类型包装成包装类的实例 —装箱</strong></p>
<ol>
<li>通过包装类的构造器实现：<br><code>int i = 500; Integer t = new Integer(i);</code></li>
<li>还可以通过字符串参数构造包装类对象：<br><code>Float f = new Float(“4.56”);</code><br><code>Long l = new Long(“asdf”); //NumberFormatException</code></li>
</ol>
<p><strong>获得包装类对象中包装的基本类型变量 —拆箱</strong><br>调用包装类的.xxxValue()方法：<code>boolean b = bObj.booleanValue();</code><br> JDK1.5之后，支持自动装箱，自动拆箱。但类型必须匹配。</p>
<p><strong>正则表达式：</strong><br>就是一个字符串，由特殊的内容组成，具有特殊的含义，用来校验其他字符串。<br>收录的符号：<br>java.util.regex.Pattern 类<br>字符类：<br>预定义字符类：<br>数量词：<br>边界匹配器：<br>maches(regex) :匹配<br>split(regex)：切割<br>replaceAll(regex, newStr):替换</p>
<p><strong>System类:</strong><br>java.lang 包<br>是一个 final 类，类中包含了类字段和类方法，不能实例化。<br>字段：<br>err: 标准错误输出流<br>out: 标准输出流<br>in: 标准输入流<br>方法：</p>
<blockquote>
<p>long currentTimeMills()<br>：该方法的作用是返回当前的计算机时间，时间的表达格式为当前计算机时间和GMT时间(格林威治时间)1970年1月1号0时0分0秒所差的毫秒数。<br>void exit(int status)：该方法的作用是退出程序。其中status的值为0代表正常退出，非零代表<br>异常退出。使用该方法可以在图形界面编程中实现程序的退出功能等。 gc():该方法的作用是请求系统进行垃圾回收。至于系统是否立刻回收，则<br>取决于系统中垃圾回收算法的实现以及系统执行时的情况。</p>
</blockquote>
<p><strong>Math类：</strong><br>java.lang 包<br>是一个 final 类，类中都是静态方法，包含了常用的一些基本数学算法。<br>常量：<br>double PI ：圆周率<br>double E : 自然底数<br>方法：</p>
<blockquote>
<p>abs(data) ：绝对值 double<br>cbrt(double a) : 开立方根<br>double ceil(double a):获取大于 a 的最小整数<br>double floor(double a): 获取小于 a 的最大整数<br>double pow(a,b) :计算a 的 b 次幂<br>double sqrt(doubel a) :计算 a 的平方根<br>long round(double a):<br>int round(float a): 四舍五入<br>double random() : 随机数 [0.0,1.0)</p>
</blockquote>
<p><strong>随机数类：</strong></p>
<blockquote>
<p>java.util.Random<br>int nextInt(int bound) :返回[0,bound)区间的随机数</p>
</blockquote>
<p><strong>Date:</strong><br>java.util 包<br>表示特定的瞬间，能精确到毫秒。<br>注意：该类中大部分方法都已过时，不建议使用。</p>
<ol>
<li>构造方法：</li>
</ol>
<blockquote>
<p>Date(): 获取当前系统值<br>Date(long mills):根据 mills 获取 Date 对象</p>
</blockquote>
<ol start="2">
<li>常用方法：</li>
</ol>
<blockquote>
<p>getTime():获取当前系统时间毫秒值<br>setTime(long mills):修改当前 date 对象表示的时间</p>
</blockquote>
<p><strong>日期对象的格式化：</strong></p>
<blockquote>
<p>java.text.DateFormat 对象，可以将日期—&gt;文本，也可以将文本—&gt;日期。 该类是一个抽象类，不可以使用 new创建对象，但是该类中提供了静态方法可以 获取到该类的一个实例对象。<br>static DateFormat getInstance() ：获取DateFormat 对象<br>String format(Date date) ：格式化 日期—&gt;文本<br>Date parse(String text) ：解析 text 文本—-&gt;日期 由于 DateFormat 显示的格式是默认格式，因此通常使用其子类 SimpleDateformat， 该子类可以指定模式。</p>
</blockquote>
<p><strong>SimpleDateFormat类</strong></p>
<blockquote>
<p>Date类的API不易于国际化，大部分被废弃了，java.text.SimpleDateFormat类是一个不与语言环境有关的方式来格式化和解析日期的具体类。它允许进行格式化：日期-&gt;文本、解析：文本-&gt;日期<br>格式化：<br>SimpleDateFormat() ：默认的模式和语言环境创建对象<br>public SimpleDateFormat(String pattern)：该构造方法可以用参数pattern指定的格式创建一个对象，该对象调用：<br>public String format(Date date)：方法格式化时间对象date<br>解析：<br>public Date parse(String source)：从给定字符串的开始解析文本，以生成一个日期。</p>
</blockquote>
<p><strong>Calendar：</strong><br>java.util 包，日历对象，可以精确到某个特定的瞬间。<br>该类是一个抽象类，因此不能使用 new 创建对象，但是类中提供了一个方法可以获取<br>到日历对象。<br>static getInstance() :获取日历对象<br>int get(int field):根据字段名获取字段值<br>其他方法：</p>
<figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br></pre></td><td class="code"><pre><span class="line">Calendar calendar = Calendar.getInstance();</span><br><span class="line">// 从一个 Calendar 对象中获取 Date 对象</span><br><span class="line">Date date = calendar.getTime();</span><br><span class="line">// 使用给定的 Date 设置此 Calendar 的时间</span><br><span class="line">date = new Date(234234235235L);</span><br><span class="line">calendar.setTime(date);</span><br><span class="line">calendar.set(Calendar.DAY_OF_MONTH, 8);</span><br><span class="line">System.out.println(&quot;当前时间日设置为8后,时间是:&quot; + calendar.getTime());</span><br><span class="line">calendar.add(Calendar.HOUR, 2);</span><br><span class="line">System.out.println(&quot;当前时间加2小时后,时间是:&quot; + calendar.getTime());</span><br><span class="line">calendar.add(Calendar.MONTH, -2);</span><br><span class="line">System.out.println(&quot;当前日期减2个月后,时间是:&quot; + calendar.getTime());</span><br></pre></td></tr></table></figure>

<p>总结：</p>
<blockquote>
<p>毫秒&lt;—-&gt;Date<br>毫秒—&gt;Date: new Date(long mills)<br>Date—-&gt;毫秒： new Date().getTime()<br>毫秒&lt;——&gt;Calendar<br>毫秒—-&gt;Calendar: setTimeInMills(long mills)<br>Calendar—-&gt;毫秒: getTimeInMills()<br>Date&lt;——–&gt;Calendar<br>Date—–&gt;Calendar : setTime(Date)<br>Calendar —–&gt;Date: getTime()</p>
</blockquote>
<p><strong>集合框架：</strong><br>就是一个容器，用于存储对象。<br><strong>数组和集合的区别：</strong><br>数组：</p>
<blockquote>
<ol>
<li>长度固定</li>
<li>元素类型固定</li>
<li>既可以存储基本类型也可以存储引用</li>
<li>存储的元素都有下标</li>
</ol>
</blockquote>
<p>集合：</p>
<blockquote>
<ol>
<li>长度不固定</li>
<li>元素类型不固定</li>
<li>只能存储引用类型</li>
<li>根据数据结构的不同，存储数据的方式也不同，有的容器有下标(List)，有的容器没有下标(Set)。</li>
</ol>
</blockquote>
<p>体系结构：<br>java.util 包<br>Collection：存储单列数据</p>
<ul>
<li>List：有序可重复</li>
<li><ul>
<li>ArrayList </li>
</ul>
</li>
<li><ul>
<li>LinkedList </li>
</ul>
</li>
<li><ul>
<li>Vector </li>
</ul>
</li>
<li>Set：无序不可重复</li>
<li><ul>
<li>HashSet </li>
</ul>
</li>
<li><ul>
<li>TreeSet </li>
</ul>
</li>
</ul>
<p><strong>注意：有序指的是存入数据的顺序和取出数据的顺序一致。</strong><br>Map：映射，存储双列数据</p>
<p><strong>Collection 常用方法演示：</strong></p>
<ol>
<li>添加<br>add(Object obj)<br>addAll(Collection coll)</li>
<li>获取有效元素的个数<br>int size()</li>
<li>清空集合<br>void clear()</li>
<li>是否是空集合<br>boolean isEmpty()</li>
<li>是否包含某个元素<br>boolean contains(Object obj)：是通过元素的equals方法来判断是否是同一个对象<br>boolean containsAll(Collection c)：也是调用元素的equals方法来比较的。拿两个集合的元素挨个比较。</li>
<li>删除<br>boolean remove(Object obj) ：通过元素的equals方法判断是否是要删除的那个元素。只会删除找到的第一个元素<br>boolean removeAll(Collection coll)：取当前集合的差集</li>
<li>取两个集合的交集<br>boolean retainAll(Collection c)：把交集的结果存在当前集合中，不影响c</li>
<li>集合是否相等<br>boolean equals(Object obj)</li>
<li>转成对象数组<br>Object[] toArray()</li>
<li>获取集合对象的哈希值<br>hashCode()</li>
<li>遍历<br>iterator()：返回迭代器对象，用于集合遍历</li>
</ol>
<p><strong>ConcurrentModificationException：并发修改异常</strong> </p>
<blockquote>
<p>当使用迭代器进行元素遍历时，不能使用集合中的方法进行删除 remove 和添加 add 操作，<br>如果操作了，则会出现并发修改异常。当获取到迭代器，此时迭代器已知集合的结构，当遍<br>历中做了增删操作，集合的结构发生了变化，但是迭代器并不知道，因此就会出现异常。</p>
</blockquote>
<p>List 特有方法演示： </p>
<blockquote>
<p>称之为叫做列表，有序可重复的特点，因此该接口中增加了围绕 index 设计的方法。<br>List除了从Collection集合继承的方法外，List 集合里添加了一些根据索引来 操作集合元素的方法。 </p>
<ol>
<li>void add(int index, Object ele):在index位置插入ele元素 </li>
<li>boolean addAll(int index,Collection eles):从index位置开始将eles中 的所有元素添加进来 </li>
<li>Object get(int index):获取指定index位置的元素 </li>
<li>int indexOf(Object obj):返回obj在集合中首次出现的位置 </li>
<li>int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置 </li>
<li>Object remove(int index):移除指定index位置的元素，并返回此元素 </li>
<li>Object set(int index, Object ele):设置指定index位置的元素为ele </li>
<li>List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex 位置的子集合</li>
</ol>
</blockquote>
<p>List 集合的遍历：</p>
<p>其他方式遍历：<br>List:<br>ArrayList：</p>
<blockquote>
<p>底层数据结构为：可变数组结构。 允许存储 null。 存储的元素会在一块连续的空间内。 查找、修改元素速度快，添加和删除速度慢。<br>线程不安全对象。</p>
</blockquote>
<p><strong>LinkedList：</strong></p>
<blockquote>
<p>底层数据结构为：链接链表算法。 允许存储 null。 存储的元素不需要在一块连续的空间。 查找、修改元素速度慢，添加和删除速度快。<br>线程不安全对象。<br>新增方法：<br>void addFirst(Object obj)<br>void addLast(Object obj)<br>Object getFirst()<br>Object getLast()<br>Object removeFirst()<br>Object removeLast()</p>
</blockquote>
<p>Vector：</p>
<blockquote>
<p>底层数据结构为：可变数组结构。用法与 ArrayList 基本相同。<br>区别是：Vector 线程安全对象，而 ArrayList线程不安全对象。 因此，做增删改查效率都慢。</p>
</blockquote>
<p><strong>泛型：</strong><br>jdk5.0,安全机制。</p>
<blockquote>
<p>由于集合容器可以存储不同类型的对象，导致做某些操作时，可能出现类型转换异常，导致程序运行停止，因此效仿数组，给集合容器添加了类型的限定，只允许存储一种类型的元素，从而将运行时期会出现的异常提前至编译时期，同时避免了在做遍历时需要的类型转 换等操作。<br>注意：不是只有集合这里使用到了泛型技术，其他地方也可以使用。<br>格式：  类名&lt;元素类型名&gt;<br>注意：元素类型名一定是引用类型名<br>一旦容器添加了泛型，相当于给容器添加了限定，只能存储泛型中指定的类型元素。<br>jdk8之后，左侧声明了泛型，右侧不需要写泛型类型只要保留尖括号即可。<br>eg: <code>ArrayList&lt;String&gt; list = new ArrayList&lt;&gt;();</code></p>
</blockquote>
<p>自定义泛型：<br>泛型类：</p>
<blockquote>
<p>格式为：<br>修饰符 类名&lt;泛型类型变量名&gt;{<br> …..<br>   }</p>
</blockquote>
<p>泛型类上定义的泛型，整个类都可以使用。当创建对象时，确定泛型的类型。<br>泛型接口：</p>
<blockquote>
<p>格式为： 修饰符 接口名&lt;泛型类型变量名&gt;{<br>  …..<br>   }</p>
</blockquote>
<p>泛型接口上定义的泛型，整个接口都可以使用。<br>确定泛型类型：</p>
<ol>
<li>定义类实现该泛型接口时，确定泛型类型</li>
<li>class 子类名&lt;泛型名&gt; implements 接口名&lt;泛型名&gt;{}<br>泛型名前后保持一致，这种方式相当于把接口上定义的泛型传递给实现类，当创建实现类对象时，确定泛型类型。</li>
</ol>
<p>泛型方法：</p>
<p>实例方法：<br>格式：<br>修饰符 &lt;泛型类型名&gt; 返回值类型 方法名(泛型类型名 变量名){<br>…..<br>}<br>当调用方法时并传递实参时，确定方法上的泛型类型。<br>注意：实例方法也可以直接使用泛型类上的泛型。</p>
<p>静态方法：<br>修饰符 static &lt;泛型类型名&gt; 返回值类型 方法名(泛型类型名 变量名){<br>…..<br>}<br>当调用方法时并传递实参时，确定方法上的泛型类型。<br>注意：静态方法与对象无关，因此不能直接使用泛型类上的泛型。</p>
<p>泛型通配符：<br>占位符 ，?,可以表示任意类型，有点类似 Object<br>当需要使用泛型技术，但是又不确定泛型的类型时。</p>
<p>泛型限定：<br>上限：? extends E , 能接收的类型为 E 类型或者是 E 的子类型<br>下限：? super E , 能接收的类型为 E 类型或者是 E 的父类型</p>
<p><strong>Set 集合：</strong><br>无序不可重复。方法全部来自 Collection，并没有添加特有方法。<br><strong>HashSet：</strong><br>底层数据结构为：哈希表算法。<br>哈希表算法：<br>首先对象先计算自身的哈希值，依赖的是 hashCode 方法，如果值唯一则直接存入。如果值不唯一，则会进行第二次校验，比较是否是同一对象，依赖的是 equals方法，如果返回 false 还是能存入，如果返回 true，则不能存入。<br>当存储定义对象时，需要保证元素的唯一：<br>重写 hashCode 和 equals 方法。<br>hashCode 重写：一般都与类中的成员属性有关系的表达式<br>equals 重写：根据需求建立对应的比较方式。<br><strong>TreeSet：</strong><br>底层数据结构为：二叉树，元素会按照自然顺序进行排序。<br>当使用该容器存储对象时，首先要将存储的对象转为 Comparable 类型，根据compareTo 方法的返回值是正整数、负整数、0 进行排序，如果返回值为 0 视为相同元素，则不能存入。<br>存储自定义对象：</p>
<ol>
<li>元素类需要实现 Comparable 接口，并实现该接口中的 compareTo 方法</li>
<li>定义类实现 Comparator 接口，并实现该接口中的 compare 方法<br>将该实现类对象作为参数传递给 TreeSet 容器的构造方法</li>
</ol>

            
                

            
        </div>
        <div class="post-tool">
            <a class="btn-thumbs-up" href="javascript:void(0);" data-cid="52" title="95">
                <i class="fa fa-thumbs-up" aria-hidden="true"></i> 打赏
            </a>
        </div>
        
        <div class="post-tags">标签：
            
            <a href="/blog/tags/java/">java</a>
            
            <a href="/blog/tags/学习/">学习</a>
            
        </div>
        
    </article>
    
        <p style="text-align: center">本文代表个人观点，内容仅供参考。若有不恰当之处，望不吝赐教！</p>
    
    
    

</div>
<script src="/blog/js/busuanzi.pure.mini.js"></script>


        </div><!-- end #main-->
    </div><!-- end #body -->
    <footer class="footer">
    <div class="footer-inner" style="text-align: center">
        <p>
            <a href="/about" title="关于">关于</a>&nbsp;&nbsp<em>·</em>&nbsp;&nbsp
            <!-- 自定义链接 -->
            <a href="/help" title="帮助">帮助</a>&nbsp;&nbsp<em>·</em>&nbsp;&nbsp
            <a href="/links" title="友链">友链</a>&nbsp;&nbsp<em>·</em>&nbsp;&nbsp
            <a href="/sitemap.xml" title="地图">地图</a>
        </p>
        <p>
            本站已建立&nbsp<a href="/timeline" id="siteBuildingTime"></a>&nbsp天，<a href="https://creativecommons.org/licenses/by-nc-sa/4.0/" target="_blank" rel="licence">采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议创作</a><br>
            ©2017-<span id="cpYear"></span> 基于&nbsp<a href="http://hexo.io" target="_blank" rel="nofollow">Hexo</a>
            ，主题采用&nbsp&nbsp<a href="https://github.com/tangkunyin/hexo-theme-jsimple" target="_blank" rel="bookmark">JSimple</a>
            ，作者&nbsp<a href="https://shuoit.net" target="_blank" rel="friend">纠结伦</a>
            ，Hosted by <a href="https://pages.github.com/" target="_blank" rel="nofollow">GitHub Pages</a>
        </p>
    </div>
</footer>
<script src="/blog/js/SimpleCore.js"></script>

</div>
<!-- search pop -->
<div class="popup search-popup local-search-popup">
    <div class="local-search-header clearfix">
        <span class="search-icon">
            <i class="fa fa-search"></i>
        </span>
        <span class="popup-btn-close">
            <i class="fa fa-times-circle"></i>
        </span>
        <div class="local-search-input-wrapper">
            <input id="local-search-input" spellcheck="false" type="text" autocomplete="off" placeholder="请输入查询关键词">
        </div>
    </div>
    <div id="local-search-result"></div>
</div>
<div class="fixed-btn">
    <a class="btn-gotop" href="javascript:"> <i class="fa fa-angle-up"></i></a>
</div>
<script>
    $(function () {
        var jsi_config = {
            buildingTime: '01/20/2018',
            current: $('.post-tags').length > 0 ? 'post' : 'archive',
            snsQRCode: '/images/sns-qrcode.png',
            donateImg: '/images/donate-qr.png',
            localSearch: { dbPath: '' },
            readMode: 'day'
        };
        
        SimpleCore.init(jsi_config);
        
    });
</script>
</body>
</html>
